package com.wxservice.controller;


import com.wxservice.domain.request.*;
import com.wxservice.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


/**
 * 调用微信接口，简化调用
 * 201请求成功且服务器已创建了新的资源
 * 400错误的请求
 * 401请登录后使用
 * 403资源不可用
 * 404请求路径没有或页面跳转路径不对
 * 500参数格式不正确，或参数错误
 */
@RestController
@RequestMapping("/api")
public class APIController {
    @Autowired
    private BasicSupportService basicSupportService;

    @Autowired
    private TemplateAndMessageService templateAndMessageService;

    @Autowired
    private WXUserManageService wxUserManageService;

    @Autowired
    private MediaService mediaService;
    /*这部分是公众号基本模板的*/


    /**
     * 获取公众号基础AccessToken，传入参数appID、appSecret进行获取，appID、appSecret必须传入
     */
    @PostMapping(value = "/accessToken")
    public Object getToken(@RequestBody PublicAccounts publicAccounts) {

        String result = basicSupportService.getBaseAccessToken(publicAccounts);
        return result;
    }






    /*这部分是模板与消息模块的*/

    /**
     * 获取该公众号所有模板信息，URL传入参数access_token进行获取，access_token必须传入
     *
     * @param access_token
     * @return
     */
    @GetMapping(value = "/templates/{access_token}")
    public Object listTemplate(@PathVariable("access_token") String access_token) {
        String result = templateAndMessageService.listTemplate(access_token);
        return result;
    }

    /**
     * 删除指定模板,根据给入的JSON/对象（access_token、template_id）进行删除,access_token、template_id必须传入
     */
    @DeleteMapping(value = "/template")
    public Object deleteTemplate(@RequestBody Template template) {
        String result = templateAndMessageService.deleteTemplate(template);
        return result;
    }


    /**
     * 发送指定模板,根据给入的JSON/对象（access_token、template_id、touser、data、miniprogram）进行发送,access_token、template_id、touser、data（data若模板无数据，可以只传{}）必须传入，miniprogram若传入，必须传入该小程序appID
     *
     * @param sentTemplate
     * @return
     */
    @PostMapping(value = "/template")
    public Object sentTemplate(@RequestBody SentTemplate sentTemplate) {
        String result = templateAndMessageService.sentTemplateToOne(sentTemplate);
        return result;
    }


    /**
     * 群发指定模板，也可用于单发,根据给入的JSON/对象（access_token、template_id、toManyUser(群发)、data、miniprogram）进行发送,access_token、template_id、toManyUser(群发)、data（data若模板无数据，可以只传{}）必须传入，miniprogram若传入，必须传入该小程序appID
     *
     * @param sentTemplates
     * @return
     */
    @PostMapping(value = "/templates")
    public Object sentTemplateToMany(@RequestBody SentTemplate sentTemplates) {
        String result = templateAndMessageService.sentTemplateToMany(sentTemplates);
        return result;
    }


    /**
     * 通过用户标签或直接群发指定消息,根据给入的JSON/对象进行群发消息。
     * 1、必须传入：access_token、msgtype对应的类型信息、msgtype（群发的消息类型，图文消息为mpnews，文本消息为text，语音为voice，音乐为music，图片为image，视频为video，卡券为wxcard）；
     * 2、msgtype选中后，需添加对应类型信息，即用于群发的消息的media_id；
     * 3、使用用户标签群发时：必须传入filter（包含①is_to_all：选择true该消息群发给所有用户，选择false可根据tag_id发送给指定群组的用户；②tag_id:群发到的标签的tag_id，参见用户管理中用户分组接口，若is_to_all值为true，可不填写tag_id）；
     * 4、msgtype为mpnews时，必须传入send_ignore_reprint：图文消息被判定为转载时，是否继续群发。 1为继续群发（转载），0为停止群发。 该参数默认为0。
     *
     * @param messageREQ
     * @return
     */
    @PostMapping(value = "/messageByTag")
    public Object sentMessageByTag(@RequestBody MessageREQ messageREQ) {
        String result = templateAndMessageService.sentMessageByTag(messageREQ);
        return result;
    }

    /**
     * 通过用户OpenID群发指定消息,根据给入的JSON/对象进行群发消息。
     * 1、必须传入：access_token、msgtype对应的类型信息、msgtype（群发的消息类型，图文消息为mpnews，文本消息为text，语音为voice，音乐为music，图片为image，视频为video，卡券为wxcard）；
     * 2、msgtype选中后，需添加对应类型信息，即用于群发的消息的media_id；
     * 3、使用用户标签群发时：必须传入filter（包含①is_to_all：选择true该消息群发给所有用户，选择false可根据tag_id发送给指定群组的用户；②tag_id:群发到的标签的tag_id，参见用户管理中用户分组接口，若is_to_all值为true，可不填写tag_id）；
     * 4、msgtype为mpnews时，必须传入send_ignore_reprint：图文消息被判定为转载时，是否继续群发。 1为继续群发（转载），0为停止群发。 该参数默认为0。
     *
     * @param messageREQ
     * @return
     */
    @PostMapping(value = "/messageByOpenIDs")
    public Object sentMessageByOpenID(@RequestBody MessageREQ messageREQ) {
        String result = templateAndMessageService.sentMessageByOpenID(messageREQ);
        return result;
    }


    /**
     * 查看消息群发的状态,根据给入的JSON/对象（access_token、msg_id）进行获取消息发送后的状态msg_status：SEND_SUCCESS表示发送成功，SENDING表示发送中，SEND_FAIL表示发送失败，DELETE表示已删除
     *
     * @param messageStatusREQ
     * @return
     */
    @PostMapping(value = "/messageStatus")
    public Object getMessageStatus(@RequestBody MessageStatusREQ messageStatusREQ) {
        String result = templateAndMessageService.getMessageStatus(messageStatusREQ);
        return result;
    }





















    /*这部分是用户模块的*/


    /**
     * 获取用户OpenId列表,每次最多1万,根据给入的JSON/对象（access_token、next_openid）进行获得,每次最多1万
     * access_token必须传入、next_openid可不传入，不传入默认为从第一个开始拉
     *
     * @param wxUserREQ
     * @return
     */
    @PostMapping(value = "/listUserOpenID")
    public Object listUserOpenID(@RequestBody WXUserREQ wxUserREQ) {
        String result = wxUserManageService.listUserOpenId(wxUserREQ);
        return result;
    }

    /**
     * 通过OpenId获取指定用户的基本信息,根据给入的JSON/对象（access_token、openid）进行获得
     * access_token、openid必须传入
     *
     * @param wxUserREQ
     * @return
     */
    @PostMapping(value = "/userInfo")
    public Object getUserInfp(@RequestBody WXUserREQ wxUserREQ) {
        String result = wxUserManageService.getUserInfo(wxUserREQ);
        return result;
    }

    /**
     * 通过OpenId获取多个用户的基本信息,每次最多获取100个,根据给入的JSON/对象（access_token、user_list）进行获得
     * access_token、user_list(其中openid必填)必须传入
     *
     * @param wxUserREQ
     * @return
     */
    @PostMapping(value = "/listUserInfo")
    public Object listUserInfo(@RequestBody WXUserREQ wxUserREQ) {
        String result = wxUserManageService.listUserInfo(wxUserREQ);
        return result;
    }


    /**
     * 增加用户标签,需要传入JSON/对象（access_token、name）
     * access_token、name必须传入
     *
     * @param tagREQ
     * @return
     */
    @PostMapping(value = "/tag")
    public Object insertTag(@RequestBody TagREQ tagREQ) {
        String result = wxUserManageService.insertTag(tagREQ);
        return result;
    }


    /**
     * 获取公众号已创建的用户标签,需要传入JSON/对象（access_token）获取该公众号所有用户标签
     * access_token必须传入
     *
     * @param access_token
     * @return
     */
    @GetMapping(value = "/tags/{access_token}")
    public Object listTag(@PathVariable("access_token") String access_token) {
        String result = wxUserManageService.listTag(access_token);
        return result;
    }


    /**
     * 修改用户标签的名字,需要传入JSON/对象（access_token、id、name（修改后的））
     * access_token、id、name必须传入
     *
     * @param tagREQ
     * @return
     */
    @PutMapping(value = "/tag")
    public Object updateTag(@RequestBody TagREQ tagREQ) {
        String result = wxUserManageService.updateTag(tagREQ);
        return result;
    }


    /**
     * 删除用户标签,需要传入JSON/对象（access_token、id），当某个标签下的粉丝超过10w时，后台不可直接删除标签。
     * access_token、id必须传入
     *
     * @param tagREQ
     * @return
     */
    @DeleteMapping(value = "/tag")
    public Object deleteTag(@RequestBody TagREQ tagREQ) {
        String result = wxUserManageService.deleteTag(tagREQ);
        return result;
    }


    /**
     * 获取标签下粉丝列表,需要传入JSON/对象（access_token、tagid、next_openid（非必填））
     * access_token、tagid必须传入，next_openid（可选，第一个拉取的OPENID，不填默认从头开始拉取）
     *
     * @param userTagREQ
     * @return
     */
    @PostMapping(value = "/usersByTag")
    public Object listUsersByTag(@RequestBody UserTagREQ userTagREQ) {
        String result = wxUserManageService.listUserByTag(userTagREQ);
        return result;
    }


    /**
     * 批量为用户打上标签,需要传入JSON/对象（access_token、tagid、openid_list（用户openID的List））
     * access_token、tagid、openid_list（用户openID的List）必须传入
     *
     * @param userTagREQ
     * @return
     */
    @PostMapping(value = "/usersToTag")
    public Object addUsersToTag(@RequestBody UserTagREQ userTagREQ) {
        String result = wxUserManageService.addUsersToTag(userTagREQ);
        return result;
    }

    /**
     * 批量为用户取消标签,需要传入JSON/对象（access_token、tagid、openid_list（用户openID的List））
     * access_token、tagid、openid_list（用户openID的List）必须传入
     *
     * @param userTagREQ
     * @return
     */
    @DeleteMapping(value = "/usersToTag")
    public Object deleteUsersToTag(@RequestBody UserTagREQ userTagREQ) {
        String result = wxUserManageService.deleteUsersToTag(userTagREQ);
        return result;
    }


    /**
     * 获取用户身上的标签列表,需要传入JSON/对象（access_token、openid）
     * access_token、openid必须传入
     *
     * @param userTagREQ
     * @return
     */
    @PostMapping(value = "/tagsByUser")
    public Object listTagsByUser(@RequestBody UserTagREQ userTagREQ) {
        String result = wxUserManageService.listTagsByUser(userTagREQ);
        return result;
    }























    /*素材管理*/


    /**
     * 上传素材,需要传入JSON/对象（access_token、type、path），type可以为图片（image支持JPG,PNG格式，1MB）、语音（voice支持播放长度不超过60s，支持AMR格式，2MB）、视频（video支持MP4格式，10MB），path是文件路径（写法如C:/hehaozhao/Desktop/222222222222.jpg）
     * access_token、type、path必须传入
     *
     * @param upLoadMediaREQ
     * @return
     * @throws Exception
     */
    @PostMapping(value = "/media")
    public Object insertMedia(@RequestBody UpLoadMediaREQ upLoadMediaREQ) throws Exception {
        String result = mediaService.insertMedia(upLoadMediaREQ);
        return result;
    }

    /**
     * 获得素材列表,需要传入JSON/对象（access_token、type、offset,count），type：素材的类型，图片（image）、视频（video）、语音 （voice）,全部素材的该偏移位置开始返回，0
     * 表示从第一个素材 返回, 返回素材的数量，取值在1到20之间
     * access_token、type、offset,count必须传入
     *
     * @param batchgetMediaREQ
     * @return
     */
    @PostMapping(value = "/listMedia")
    public Object listMedia(@RequestBody BatchgetMediaREQ batchgetMediaREQ) {
        String result = mediaService.listMedia(batchgetMediaREQ);
        return result;
    }

    /**
     * 删除单个素材,需要传入JSON/对象（access_token、media_id）
     * access_token、media_id必须传入
     *
     * @param allMediaREQ
     * @return
     */
    @DeleteMapping(value = "/media")
    public Object deleteMedia(@RequestBody AllMediaREQ allMediaREQ) {
        String result = mediaService.deleteMedia(allMediaREQ);
        return result;
    }
}

